
#include "mywin.h"

// 主界面对象
static lv_obj_t * main_win = NULL;
// 视频界面对象
static lv_obj_t * video_win = NULL;
// 音乐界面对象
static lv_obj_t * music_win = NULL;
extern int fd;
// 视频播放器的进度条对象
static lv_obj_t * v_slider = NULL;
static lv_obj_t * v_list   = NULL;
static lv_obj_t * pic_obj; // 图片对象

// 歌单列表
static lv_obj_t * m_list = NULL;
static lv_style_t style; // 中文

// static char local_music_path[]="/";//音乐文件路径
// static char local_pic_path[]="/";//图片文件路径
// static char local_words_path[]="/";//歌词文件路径

static lv_obj_t * play_mode;            // 下拉列表对象，播放模式
static char music_path[100][1024];      // 音乐路径
static char pic_path[100][1024];        // 图片路径
static char words_path[100][1024];      // 歌词路径
static char words_buf[5 * 1024] = {0};  // 放歌词的数组
static int music_num            = 0;    // 音乐数量
static int music_num1           = 0;    // 记录歌词文件位置数量
static int music_index          = -1;   // 当前音乐的下标值，用于寻找上下首
static bool play_flag           = 0;    // 播放音乐开关
static lv_obj_t * m_slider      = NULL; // 歌曲播放进度条
static lv_obj_t * volume_slider;        // 音量滑条对象
static lv_obj_t * volume_label;         // 音量标签
static lv_obj_t * title_label;          // 图片信息标签
static lv_obj_t * words_label;          // 歌词标签
static float time_music_now;
static char words_line[1024];
// 音乐进度条事件
static void music_event_cb(lv_event_t * e);

static void music_btn_event_callback(lv_event_t * event);

static void video_btn_event_cb(lv_event_t * e);

static void btn_handler(lv_event_t * e);
static void slider_event_cb(lv_event_t * e);

// video 点击播放事件函数
static void play_btn_event_callback(lv_event_t * event);
static void event_handler(lv_event_t * e);
static void video_event_cb(lv_event_t * e);

// 零碎视频图标按钮的点击事件
static void video_other_btn1(lv_event_t * event);
static void video_other_btn2(lv_event_t * event);
static void video_other_btn3(lv_event_t * event);
static void video_other_btn4(lv_event_t * event);
static void video_other_btn5(lv_event_t * event);
static void video_other_btn6(lv_event_t * event);

// 歌曲列表点击播放
static void event_handler_music_list(lv_event_t * e);

static lv_ft_info_t info; // 字体结构体
// 初始化字体
void show_font()
{
    /*Create a font*/
    /*FreeType uses C standard file system, so no driver letter is required.*/
    info.name   = "/usr/share/fonts/DroidSansFallback.ttf";
    info.weight = 18; // 字体大小
    info.style  = FT_FONT_STYLE_NORMAL;
    info.mem    = NULL;
    if(!lv_ft_font_init(&info)) {
        LV_LOG_ERROR("create failed.");
    }
}

// 初始化图片的父对象，即图片都在这个对象中显示
void init_pic_parent_obj()
{
    // 在屏幕中创建一个对象
    lv_obj_t * img = lv_obj_create(music_win);
    // 取消滚动
    lv_obj_clear_flag(img, LV_OBJ_FLAG_SCROLLABLE);
    lv_obj_set_size(img, 200, 200);
    lv_obj_align(img, LV_ALIGN_CENTER, 0, -60);
    // lv_obj_set_style_pad_all
    // 图片对象
    pic_obj = lv_img_create(img);
    lv_obj_center(pic_obj);
}

// 初始化歌曲信息的父对象
void init_title_obj()
{
    show_font();
    
    // 在屏幕中创建一个对象
    lv_obj_t * title = lv_obj_create(music_win);
    lv_obj_clear_flag(title, LV_OBJ_FLAG_SCROLLABLE); // 禁用滚动
    lv_obj_set_size(title, 200, 50);
    lv_obj_align(title, LV_ALIGN_TOP_MID, 0, 20);

    // 标题标签
    title_label = lv_label_create(title);

    // 添加字体
    lv_obj_add_style(title_label, &style, 0);
    lv_obj_center(title_label);
    lv_label_set_text(title_label, "OpenMusicJourney");
    // 歌词标签
    words_label = lv_label_create(music_win);
    lv_obj_add_style(words_label, &style, 0);
    lv_obj_align(words_label, LV_ALIGN_CENTER, 0, 70);
    lv_label_set_text(words_label, "Lyrics 歌词");
}
// 视频进度条控件的创建和设计
void video_slider(lv_obj_t * parent, int x, int y, int w, int h)
{

    /*把进度条创建在播放界面上*/
    v_slider = lv_slider_create(parent);
    
    lv_obj_set_pos(v_slider, x, y);

    // 设置进度条的宽度
    lv_obj_set_size(v_slider, w, h);

    // 设置进度条的范围
    lv_slider_set_range(v_slider, 0, 100); // 百分比设计进度

    // 添加进度条的 松开 事件
    lv_obj_add_event_cb(v_slider, video_event_cb, LV_EVENT_RELEASED, NULL);
}

// 视频列表的创建
void video_list(lv_obj_t * parent, int x, int y, int w, int h)
{
    lv_obj_t * btn;
    v_list = lv_list_create(parent); // 创建列表对象
    lv_obj_set_size(v_list, w, h);   // 设置大小
    lv_obj_set_pos(v_list, x, y);    // 设置位置

    // 在列表里面添加按钮
    lv_list_add_text(v_list, "video"); // 添加列表的项目栏
    btn = lv_list_add_btn(v_list, LV_SYMBOL_FILE, "dream.avi");
    lv_obj_add_event_cb(btn, event_handler, LV_EVENT_CLICKED, NULL);
    btn = lv_list_add_btn(v_list, LV_SYMBOL_FILE, "Shake_it_off2.avi");
    lv_obj_add_event_cb(btn, event_handler, LV_EVENT_CLICKED, NULL);
    btn = lv_list_add_btn(v_list, LV_SYMBOL_FILE, "tianhou.avi");
    lv_obj_add_event_cb(btn, event_handler, LV_EVENT_CLICKED, NULL);
}

// 创建图标按钮，并返回按钮用来写入事件函数
lv_obj_t * lv_imgbtn(lv_obj_t * parent, int x, int y, int w, int h, char * pic_path)
{
    static lv_style_t style_pr;
    // 1.初始化特效
    lv_style_init(&style_pr);

    lv_style_set_img_recolor_opa(&style_pr, LV_OPA_40);
    lv_style_set_img_recolor(&style_pr, lv_color_black());
    lv_style_set_transform_height(&style_pr, 20);

    // 2.创建图标按钮
    lv_obj_t * imgbtn = lv_imgbtn_create(parent);
    if(imgbtn == NULL) {
        LV_LOG_ERROR("lv_imgbtn_create fail:"); // 输出错误提示
        return NULL;
    }

    // 设置按钮的大小
    lv_obj_set_size(imgbtn, w, h); //"S:/1.png"
    // 设置按钮的图片
    lv_imgbtn_set_src(imgbtn, LV_IMGBTN_STATE_RELEASED, NULL, pic_path, NULL);
    // 添加按下的特效
    // lv_obj_add_style(imgbtn1, &style_def, 0);
    lv_obj_add_style(imgbtn, &style_pr, LV_STATE_PRESSED);
    // 设置按钮的位置
    lv_obj_align(imgbtn, LV_ALIGN_TOP_LEFT, x, y);

    return imgbtn;
}

// 显示视频播放器界面
static void show_video_win()
{
    // 1.创建一个对象,大小与屏幕一致
    video_win = lv_obj_create(lv_scr_act());
    lv_obj_set_size(video_win, 800, 480);

    // 2.在视频界面中创建一个按钮
    lv_obj_t * label = lv_label_create(video_win);

    // 3.设置标签的内容
    lv_label_set_text(label, "VIDEO");

    // 4.放入中间
    lv_obj_center(label);

    // 5.显示播放按钮，初始界面只有一个video和一个播放按钮
    lv_obj_t * play = lv_imgbtn(video_win, 355, 255, 50, 50, "S:/play.png");

    // 6.增加点击的播放事件函数
    lv_obj_add_event_cb(play, play_btn_event_callback, LV_EVENT_CLICKED, NULL);
}

// 两个返回初始界面函数
static void music_return(lv_event_t * e)
{
    LV_LOG_USER("music_return");
    system("killall mplayer");
    // 删除音乐界面
    lv_obj_del(music_win);

    // 显示主界面
    show_main_win();
}
static void video_return(lv_event_t * e)
{
    LV_LOG_USER("video_return");
    system("killall mplayer");

    // 删除视频界面
    lv_obj_del(video_win);

    // 显示主界面
    show_main_win();
}
lv_obj_t * label_time; // 音乐进度条函数

// 音乐按钮的创建
void show_button()
{
    // 按钮的风格设置
    static lv_style_t btn_style;
    lv_style_init(&btn_style);
    /*Set a background color and a radius*/
    lv_style_set_radius(&btn_style, 90);
    lv_style_set_bg_opa(&btn_style, LV_OPA_COVER);
    lv_style_set_bg_color(&btn_style, lv_palette_lighten(LV_PALETTE_BLUE, 1)); // 按钮色
    /*Add a shadow*/
    lv_style_set_shadow_width(&btn_style, 55);
    lv_style_set_shadow_color(&btn_style, lv_palette_main(LV_PALETTE_BLUE)); // 背景色

    // 创建一个返回按钮
    lv_obj_t * btn_ret = lv_btn_create(music_win);
    // 设置按钮的大小
    lv_obj_set_size(btn_ret, 80, 50);
    // 把按钮放入右下角
    lv_obj_align(btn_ret, LV_ALIGN_BOTTOM_RIGHT, 0, 0);
    // 添加按钮的事件 ，当按钮 被点击后就会触发  event_cb 函数
    lv_obj_add_event_cb(btn_ret, music_return, LV_EVENT_CLICKED, NULL);
    // 创建一个标签对象  ，在按钮上
    lv_obj_t * label1 = lv_label_create(btn_ret);
    // 设置标签的文字
    lv_label_set_text(label1, "return");
    // 把标签放入按钮的中央
    lv_obj_center(label1);

    // 时间标签
    label_time = lv_label_create(music_win);
    // 设置长文本的模式  直接正常显示
    lv_label_set_long_mode(label_time, LV_LABEL_LONG_WRAP); /*Break the long lines*/
    // 设置文本颜色是否生效 #0000ff Re-color#  文本会变成 蓝色
    lv_label_set_recolor(label_time, true); /*Enable re-coloring by commands in the text*/
    // 设置标签的文字
    lv_label_set_text(label_time, "0:0");
    // 设置标签的宽度
    lv_obj_set_width(label_time, 100); /*Set smaller width to make the lines wrap*/
    // 设置央样式文本的对齐规则
    lv_obj_set_style_text_align(label_time, LV_TEXT_ALIGN_CENTER, 0);
    // 设置对象的对齐规则
    lv_obj_align(label_time, LV_ALIGN_BOTTOM_RIGHT, -175, -74);

    lv_obj_t * btn_pause = lv_btn_create(lv_scr_act());
    // 按钮事件
    lv_obj_add_event_cb(btn_pause, btn_handler, LV_EVENT_ALL, "pause");
    // 位置
    lv_obj_align(btn_pause, LV_ALIGN_BOTTOM_MID, 40, -30);
    // 大小
    lv_obj_set_size(btn_pause, 60, 60);
    // 图标
    lv_obj_set_style_bg_img_src(btn_pause, LV_SYMBOL_PAUSE, 0);
    // 添加风格
    lv_obj_add_style(btn_pause, &btn_style, 0);

    // 播放按钮
    lv_obj_t * btn_play = lv_btn_create(music_win);
    lv_obj_add_event_cb(btn_play, btn_handler, LV_EVENT_ALL, "play");
    lv_obj_align(btn_play, LV_ALIGN_BOTTOM_MID, -40, -10);
    lv_obj_set_size(btn_play, 60, 60);
    lv_obj_set_style_bg_img_src(btn_play, LV_SYMBOL_PLAY, 0);
    lv_obj_add_style(btn_play, &btn_style, 0);

    // 快进
    lv_obj_t * btn_forward = lv_btn_create(music_win);
    lv_obj_add_event_cb(btn_forward, btn_handler, LV_EVENT_ALL, "forward");
    lv_obj_set_size(btn_forward, 60, 60);
    lv_obj_align(btn_forward, LV_ALIGN_BOTTOM_MID, 120, -10);
    lv_obj_set_style_bg_img_src(btn_forward, LV_SYMBOL_RIGHT LV_SYMBOL_RIGHT, 0);
    lv_obj_add_style(btn_forward, &btn_style, 0);
    // 快退
    lv_obj_t * btn_back = lv_btn_create(music_win);
    lv_obj_add_event_cb(btn_back, btn_handler, LV_EVENT_ALL, "back");
    lv_obj_set_size(btn_back, 60, 60);
    lv_obj_align(btn_back, LV_ALIGN_BOTTOM_MID, -120, -10);
    lv_obj_set_style_bg_img_src(btn_back, LV_SYMBOL_LEFT LV_SYMBOL_LEFT, 0);
    lv_obj_add_style(btn_back, &btn_style, 0);

    // // 下一首
    // lv_obj_t * btn_next = lv_btn_create(lv_scr_act());
    // lv_obj_add_event_cb(btn_next, btn_handler, LV_EVENT_ALL, "next_music");
    // lv_obj_set_size(btn_next, 60, 60);
    // lv_obj_align(btn_next, LV_ALIGN_BOTTOM_MID, 200, -20);
    // lv_obj_set_style_bg_img_src(btn_next, LV_SYMBOL_NEXT, 0);
    // lv_obj_add_style(btn_next, &btn_style, 0);
    // // 上一首
    // lv_obj_t * btn_prev = lv_btn_create(lv_scr_act());
    // lv_obj_add_event_cb(btn_prev, btn_handler, LV_EVENT_ALL, "prev_music");
    // lv_obj_set_size(btn_prev, 60, 60);
    // lv_obj_align(btn_prev, LV_ALIGN_BOTTOM_MID, -200, -20);
    // lv_obj_set_style_bg_img_src(btn_prev, LV_SYMBOL_PREV, 0);
    // lv_obj_add_style(btn_prev, &btn_style, 0);
}
// 检索本地歌单以及歌词文件
void get_music_path()
{
    // 读目录,mp3后缀保存到数组
    DIR * dirp = opendir("/");
    if(dirp == NULL) {
        perror("/");
        exit(0);
    }
    struct dirent * msg;
    strcpy(pic_path[0], "S:psd.jpg");
    strcpy(pic_path[1], "S:psd1.jpg");
    strcpy(pic_path[2], "S:psd2.jpg");
    while(1) {
        msg = readdir(dirp);                // 读取目录信息
        if(msg == NULL) break;              // 什么都没有就退出
        if(msg->d_name[0] == '.') continue; // 跳过.目录
        if(strstr(msg->d_name, ".mp3")) {
            // 拼接歌曲文件路径
            sprintf(music_path[music_num], "%s", msg->d_name);
            printf("ge=%s\n", music_path[music_num]);
            music_num++;
        }
        if(strstr(msg->d_name, ".lrc")) {
            sprintf(words_path[music_num1], "%s", msg->d_name);
            printf("ming=%s\n", words_path[music_num1]);
            music_num1++;
        }
    }
    printf("检索歌单完成 共%d\n", music_num);
}

// 把找到的歌曲做成列表按钮
static void show_list()
{
    printf("begin\n");
    // 创建列表以及风格添加
    m_list = lv_list_create(music_win);
    lv_obj_add_style(m_list, &style, 0);
    lv_obj_set_size(m_list, 180, 150);
    // 列表位置
    lv_obj_align(m_list, LV_ALIGN_RIGHT_MID, -20, 0);
    lv_list_add_text(m_list, "music-list");
    lv_obj_t * btn; // 按钮对象
    for(int i = 0; i < music_num; i++) {
        printf("path=%s\n", music_path[i]);
        // 参数：列表对象，图标宏，按钮名
        btn = lv_list_add_btn(m_list, NULL, music_path[i]);
        // 列表按钮风格
        lv_obj_add_style(m_list, &style, 0);
        // 触发事件，把下标传递
        lv_obj_add_event_cb(btn, event_handler_music_list, LV_EVENT_CLICKED, i);
    }
}
// 音乐进度条控件的创建和设计
void music_slider(lv_obj_t * parent, int x, int y, int w, int h)
{

    /*把进度条创建在播放界面上*/
    m_slider = lv_slider_create(parent);

    lv_obj_set_pos(m_slider, x, y);

    // 设置进度条的宽度
    lv_obj_set_size(m_slider, w, h);

    // 设置进度条的范围
    lv_slider_set_range(m_slider, 0, 100); // 百分比设计进度

    // 添加进度条的 松开 事件
    lv_obj_add_event_cb(m_slider, music_event_cb, LV_EVENT_RELEASED, NULL);
}

// 显示滑动条
static void show_slider(void)
{
    music_slider(music_win, 180, 320, 400, 13);
    // 音量调节
    volume_slider = lv_slider_create(music_win);
    lv_obj_align(volume_slider, LV_ALIGN_LEFT_MID, 20, 20);                                // 位置
    lv_obj_add_event_cb(volume_slider, slider_event_cb, LV_EVENT_VALUE_CHANGED, "volume"); // 事件
    lv_obj_set_size(volume_slider, 18, 180);                                               // 大小
    lv_slider_set_value(volume_slider, 100, LV_ANIM_OFF);                                  // 初始值
    /*标签 音量大小 */
    volume_label = lv_label_create(music_win);
    lv_label_set_text(volume_label, "100");
    lv_obj_align_to(volume_label, volume_slider, LV_ALIGN_OUT_BOTTOM_MID, 0, 10);
    lv_obj_t * label = lv_label_create(music_win);
    lv_obj_add_style(label, &style, 0);
    lv_label_set_text(label, "volum");
    lv_obj_align_to(label, volume_label, LV_ALIGN_OUT_TOP_MID, 0, -210);
}
// 显示界面
static void display_interface()
{
    // 显示歌单列表
    show_list();

    // 按钮
    show_button();

    // 进度条
    show_slider();
}
// 显示音乐播放界面
void show_music_win()
{
    // 创建一个对象
    music_win = lv_obj_create(lv_scr_act()); // 创建一个独立的对象，大小与屏幕一致
    lv_obj_set_size(music_win, 800, 480);

    get_music_path(); // 检索本地歌单

    // 初始化图片父对象
    init_pic_parent_obj();
    init_title_obj();
    // 音乐界面的显示
    display_interface();
}

// 显示初始界面
void show_main_win()
{
    // 1.创建主界面(对象)
    main_win = lv_obj_create(lv_scr_act());

    // 2.设置主界面的大小和屏幕一致
    lv_obj_set_size(main_win, 800, 480);

    // 3.在主界面中创建音乐与视频的图标(图片按钮)
    lv_obj_t * video = lv_imgbtn(main_win, 100, 100, 200, 200, "S:/video.png");
    // 添加视频按钮的点击事件
    lv_obj_add_event_cb(video, video_btn_event_cb, LV_EVENT_CLICKED, NULL);

    // 4.添加音乐按钮点击事件
    lv_obj_t * music = lv_imgbtn(main_win, 400, 100, 200, 200, "S:/music.png");
    lv_obj_add_event_cb(music, music_btn_event_callback, LV_EVENT_CLICKED, NULL);
}

// 零碎图标按钮的创建
void video_other_btn_create()
{
    lv_obj_t * other_btn1 = lv_imgbtn(video_win, 30, 390, 50, 50, "S:/stop.png");
    lv_obj_add_event_cb(other_btn1, video_other_btn1, LV_EVENT_CLICKED, NULL);

    lv_obj_t * other_btn2 = lv_imgbtn(video_win, 110, 390, 50, 50, "S:/continue.png");
    lv_obj_add_event_cb(other_btn2, video_other_btn2, LV_EVENT_CLICKED, NULL);

    lv_obj_t * other_btn3 = lv_imgbtn(video_win, 190, 390, 50, 50, "S:/back.png");
    lv_obj_add_event_cb(other_btn3, video_other_btn3, LV_EVENT_CLICKED, NULL);

    lv_obj_t * other_btn4 = lv_imgbtn(video_win, 270, 390, 50, 50, "S:/forword.png");
    lv_obj_add_event_cb(other_btn4, video_other_btn4, LV_EVENT_CLICKED, NULL);

    lv_obj_t * other_btn5 = lv_imgbtn(video_win, 350, 390, 50, 50, "S:/jian.png");
    lv_obj_add_event_cb(other_btn5, video_other_btn5, LV_EVENT_CLICKED, NULL);

    lv_obj_t * other_btn6 = lv_imgbtn(video_win, 430, 390, 50, 50, "S:/jia.png");
    lv_obj_add_event_cb(other_btn6, video_other_btn6, LV_EVENT_CLICKED, NULL);
}

/*****************************👇是点击函数************************************/

// 获取事件任务线程
void * get_time_task(void * arg)
{
    // 写代码时，要考虑计算机的感受 ！！！

    while(1) {
        system("echo  get_percent_pos  >  /pipe");

        sleep(1); // 不需要进行任何运算
    }
}
void * get_time_task1(void * arg)
{
    while(1) {
        //system("echo get_time_length > /pipe");
        system("echo  get_percent_pos  >  /pipe");
        system("echo get_time_pos > /pipe");
        sleep(1); // 不需要进行任何运算
    }
}
static void video_btn_event_cb(lv_event_t * event)
{
    // 获取事件号
    lv_event_code_t code = lv_event_get_code(event);

    // 判断事件的状态
    if(code == LV_EVENT_CLICKED) {
        // 删除主界面
        lv_obj_del(main_win);

        // 显示视频界面
        show_video_win();
    }
}
static void music_btn_event_callback(lv_event_t * event)
{
    // 获取事件号
    lv_event_code_t code = lv_event_get_code(event);

    // 判断事件的状态
    if(code == LV_EVENT_CLICKED) {
        // 删除主界面
        lv_obj_del(main_win);

        // 显示视频界面
        show_music_win();
    }
}
char arr[128]     = {0};
lv_obj_t * label1 = NULL;

// 视频播放任务
void * play_task(void * arg)
{
    // mkfifo("/pipe", 0777);
    //  加载mplayer 播放器进程
    FILE * fp = popen("mplayer -slave -quiet -input  file=/pipe  -geometry  0:0 -zoom -x 600 -y 350  /dream.avi", "r");
    if(fp == NULL) {
        perror("播放视频失败\n");
        return NULL;
    }
    // 重点开启一个，写入获取进度线程
    pthread_t t_tid;
    pthread_create(&t_tid, NULL, get_time_task, NULL);
    pthread_detach(t_tid); // 直接设置为分离属性，无需回收资源
    int i = 0;
    while(1) {
        char buf[1024] = {0};
        if(i < 1) {
            system("echo get_time_length > /pipe");
            char * p = fgets(buf, 1024, fp);
            if(p == NULL) {
                break;
            }
            if(strstr(buf, "ANS_LENGTH=")) {
                int value = 0;
                int ws    = 0;
                sscanf(buf, "ANS_LENGTH=%d\n", &value);
                ws    = value % 60;
                value = value / 60;
                bzero(arr, sizeof(arr));
                sprintf(arr, "%d:%d", value, ws);
                label1 = lv_label_create(video_win);
                // 设置长文本的模式  直接正常显示
                lv_label_set_long_mode(label1, LV_LABEL_LONG_WRAP); /*Break the long lines*/
                // 设置文本颜色是否生效 #0000ff Re-color#  文本会变成 蓝色
                lv_label_set_recolor(label1, true); /*Enable re-coloring by commands in the text*/
                // 设置标签的文字
                lv_label_set_text(label1, arr);
                // 设置标签的宽度
                lv_obj_set_width(label1, 100); /*Set smaller width to make the lines wrap*/
                // 设置央样式文本的对齐规则
                lv_obj_set_style_text_align(label1, LV_TEXT_ALIGN_CENTER, 0);
                // 设置对象的对齐规则
                lv_obj_align(label1, LV_ALIGN_BOTTOM_RIGHT, -100, -100);
                i++;
            }
        }
        char * p = fgets(buf, 1024, fp); // 读取播放器返回的信息
        if(p == NULL) {
            break;
        }

        // printf("msg=%s\n", p); // ANS_PERCENT_POSITION=11

        // 处理返回的信息
        if(strstr(buf, "ANS_PERCENT_POSITION=")) {
            int value = 0;
            sscanf(buf, "ANS_PERCENT_POSITION=%d\n", &value);

            // 设置滑块
            // 上锁
            pthread_mutex_lock(&mutex);

            lv_slider_set_value(v_slider, value, LV_ANIM_OFF);

            // 解锁
            pthread_mutex_unlock(&mutex);
        }
    }
    // 杀死线程
    pthread_cancel(t_tid);
    pclose(fp);
}
void * play_task_other(void * arg)
{
    char buf[1024] = {0};
    strcpy(buf, (char *)arg);
    // printf("buf=%s\n", buf);
    char arr[1024] = {0};
    mkfifo("/pipe", 0777);
    sprintf(arr, "%s%s", "mplayer -slave -quiet -input  file=/pipe  -geometry  0:0 -zoom -x 600 -y 350  /", buf);
    // 加载mplayer 播放器进程
    FILE * fp = popen(arr, "r");
    if(fp == NULL) {
        perror("播放视频失败\n");
        return NULL;
    }
    // 重点开启一个，写入获取进度线程
    pthread_t t_tid;
    pthread_create(&t_tid, NULL, get_time_task, NULL);
    pthread_detach(t_tid); // 直接设置为分离属性，无需回收资源
    int i = 0;
    while(1) {
        char buf[1024] = {0};
        if(i < 1) {
            system("echo get_time_length > /pipe");
            char * p = fgets(buf, 1024, fp);
            if(p == NULL) {
                break;
            }
            if(strstr(buf, "ANS_LENGTH=")) {
                int value = 0;
                int ws    = 0;
                sscanf(buf, "ANS_LENGTH=%d\n", &value);
                ws    = value % 60;
                value = value / 60;
                bzero(arr, sizeof(arr));
                sprintf(arr, "%d:%d", value, ws);
                // 重新设置尾事件的内容
                lv_label_set_text(label1, arr);
                i++;
            }
        }
        char * p = fgets(buf, 1024, fp); // 读取播放器返回的信息
        if(p == NULL) {
            break;
        }
        // printf("msg=%d\n", buf);
        //   处理返回的信息
        if(strstr(buf, "ANS_PERCENT_POSITION=")) {
            int value = 0;
            sscanf(buf, "ANS_PERCENT_POSITION=%d\n", &value);

            // 设置滑块
            // 上锁
            pthread_mutex_lock(&mutex);
            lv_slider_set_value(v_slider, value, LV_ANIM_OFF);
            // 解锁
            pthread_mutex_unlock(&mutex);
        }
    }
    // 杀死线程
    pthread_cancel(t_tid);
    pclose(fp);
}

static void video_other_btn1(lv_event_t * event)
{
    system("killall -19 mplayer");
}
static void video_other_btn2(lv_event_t * event)
{
    system("killall -18 mplayer");
}
static void video_other_btn3(lv_event_t * event)
{
    system("echo seek -10 > /pipe");
}
static void video_other_btn4(lv_event_t * event)
{
    system("echo seek +10 > /pipe");
}
static void video_other_btn5(lv_event_t * event)
{
    system("echo volume -10 > /pipe");
}
static void video_other_btn6(lv_event_t * event)
{
    system("echo volume +10 > /pipe");
}

// 播放视频按钮的事件函数
static void play_btn_event_callback(lv_event_t * event)
{
    // 1.播放视频,先杀死之前的视频
    system("killall mplayer");

    // 2.创建一个线程播放视频
    pthread_t tid;
    pthread_create(&tid, NULL, play_task, NULL);

    // 3.打印其他的一些按钮
    video_slider(video_win, 10, 355, 600, 30);      // 进度条

    lv_obj_t * btn = lv_btn_create(video_win);      // 创建返回按钮
    lv_obj_set_size(btn, 80, 60);                   // 设置大小
    lv_obj_align(btn, LV_ALIGN_BOTTOM_RIGHT, 0, 0); // 位置
    lv_obj_add_event_cb(btn, video_return, LV_EVENT_CLICKED, NULL);
    // 创建一个标签对象,在按钮上
    lv_obj_t * label1 = lv_label_create(btn);
    // 设置标签的文字
    lv_label_set_text(label1, "return");
    // 把标签放入按钮的中央
    lv_obj_center(label1);

    // 列表选择播放
    video_list(video_win, 610, 100, 150, 200); // 列表按钮

    // 创建其它的图标按钮(y=400)
    video_other_btn_create();
}

// 视频滑块事件函数
static void video_event_cb(lv_event_t * e)
{
    // 获取触发事件的对象
    lv_obj_t * slider = lv_event_get_target(e);
    char buf[8];
    lv_snprintf(buf, sizeof(buf), "%d%%", (int)lv_slider_get_value(slider));
    int pos_time = (int)lv_slider_get_value(slider);
    int min = 0, second = 0, fs = 0;
    sscanf(arr, "%d:%d", &min, &second);
    int length_time = 60 * min + second;
    sscanf(buf, "%d", &fs);
    double xiaoshu = fs * 0.01;
    int set_time   = (int)(length_time * xiaoshu);
    char arr[128]  = {0};
    sprintf(arr, "seek %d 2", set_time);
    write(fd, arr, strlen(arr));
    // printf("当前进度 %s\n", buf);
}
// 视频列表事件函数
void open_newvid(char * buf)
{
    // 1.播放视频,先杀死之前的视频
    system("killall mplayer");

    // 2.创建一个线程播放视频
    pthread_t tid;
    pthread_create(&tid, NULL, play_task_other, buf);
}

static void event_handler(lv_event_t * e)
{
    char buf[1024]       = {0};
    lv_event_code_t code = lv_event_get_code(e);
    lv_obj_t * obj       = lv_event_get_target(e);
    if(code == LV_EVENT_CLICKED) {
        strcpy(buf, lv_list_get_btn_text(v_list, obj));
        // printf("buf=%s\n",buf);
        //  函数(关闭原来的视频，开启新视频)
        open_newvid(buf);
    }
}

// words_label歌词标签
void * task_time_geci(void * arg)
{
    printf("gc time=%s\n",(char*)arg);
    char * p = strstr(words_buf, (char *)arg);
    if(p != NULL) {
        char buf[1024] = {0};
        sscanf(p, "%s", buf);
        char * q = strrchr(buf, ']');
        sscanf(++q, "%s", buf);
        if(strcmp(buf, words_line)) {
            strcpy(words_line, buf);
            puts(words_line);
            pthread_mutex_lock(&mutex);
            lv_label_set_text(words_label, words_line);
            pthread_mutex_unlock(&mutex);
        }
    }
}
char arr1[1024] = {0};
FILE * fp       = NULL;
// 音乐播放按钮事件
void * play_music_other(void * arg)
{
    printf("线程开始\n");
    sleep(1);
    // 根据点击歌曲列表的下标来播放对应歌曲
    sprintf(arr1, "%s%s", "mplayer -slave -quiet -input  file=/pipe ", music_path[music_index]);
    printf("arr1=%s\n", arr1);
    // mkfifo("/pipe", 0777);
    //  加载mplayer 播放器进程
    fp        = popen(arr1, "r");
    play_flag = 1;
    // 重点开启一个，写入获取进度线程
    pthread_t m_tid;
    pthread_create(&m_tid, NULL, get_time_task1, NULL);
    pthread_detach(m_tid); // 直接设置为分离属性，无需回收资源
    int i = 0;
    while(1) {
        char buf[1024] = {0};
        if(i < 1) {
            system("echo get_time_length > /pipe");
            char * p = fgets(buf, 1024, fp);
            if(p == NULL) {
                break;
            }
            if(strstr(buf, "ANS_LENGTH=")) {
                int value = 0;
                int ws    = 0;
                sscanf(buf, "ANS_LENGTH=%d\n", &value);
                printf("value=%d\n", value);
                ws    = value % 60;
                value = value / 60;
                bzero(arr1, sizeof(arr1));
                sprintf(arr1, "%d:%d", value, ws);
                // 重新设置尾事件的内容
                lv_label_set_text(label_time, arr1);
                i++;
            }
        }
        // bzero(buf, sizeof(buf));
        char * p = fgets(buf, 1024, fp); // 读取播放器返回的信息
        if(p == NULL) {
            break;
        }
        // printf("buf=%s\n",buf);
        //   处理返回的信息
        if(strstr(buf, "ANS_PERCENT_POSITION=")) {
            int value = 0;
            sscanf(buf, "ANS_PERCENT_POSITION=%d\n", &value);
            // 设置滑块
            // 上锁
            // printf("value1=%d\n", value);
            pthread_mutex_lock(&mutex1);
            lv_slider_set_value(m_slider, value, LV_ANIM_OFF);
            // 解锁
            pthread_mutex_unlock(&mutex1);
            // printf("value1=%d\n", value++);
        }
        if(strstr(buf, "ANS_TIME_POSITION=")) {
            sscanf(buf, "ANS_TIME_POSITION=%2f\n",&time_music_now);
            //printf("time_music_now=%f\n",time_music_now);

            int time1 = (int)time_music_now;
            //printf("time1=%d\n",time1);
            int min,second;
            min = time1 / 60;
            second = time1 % 60;
            char time[128] = {0};
            sprintf(time,"0%d:%d",min,second);
            //printf("time=%s\n",time);
            pthread_t time_now;
            pthread_create(&time_now,NULL,task_time_geci,time);
            pthread_detach(time_now);

        }
    }
    // 杀死线程
    pthread_cancel(m_tid);
    pclose(fp);
}

// 播放一首音乐
void play_one_music()
{
    printf("播放音乐启动\n");
    // 先杀死其他的音乐任务
    if(play_flag) system("killall mplayer");
    pthread_t tid;
    pthread_create(&tid, NULL, play_music_other, NULL);
}
static void event_handler_music_list(lv_event_t * e)
{
    // 获取事件码
    lv_event_code_t code = lv_event_get_code(e);
    // 获取事件对象,这里是按钮
    lv_obj_t * obj = lv_event_get_target(e);
    // 如果点击按钮
    if(code == LV_EVENT_CLICKED) {
        // 打印按钮中的文本
        // LV_LOG_USER("Clicked: %s", lv_list_get_btn_text(music_list, obj));
        printf("Clicked  %s\n", lv_list_get_btn_text(m_list, obj));
        // 当前播放中的音乐下标更新为点击列表的下标
        music_index = 0;
        music_index = lv_event_get_user_data(e);
        printf("music_index=%d\n", music_index);
        printf("pic_path=%s\n", pic_path[music_index]);

        lv_img_set_src(pic_obj,pic_path[music_index]);
        FILE * fp_gc = fopen(words_path[music_index], "r");
        if(fp_gc == NULL) {
            printf("open fail:\n");
        }
        int size = fread(words_buf, 1, 5 * 1024, fp_gc);
        printf("size = %d\n", size);
        play_one_music();
    }
}

static void music_event_cb(lv_event_t * e)
{
    lv_obj_t * slider = lv_event_get_target(e);
    char buf[8];
    lv_snprintf(buf, sizeof(buf), "%d%%", (int)lv_slider_get_value(slider));
    int pos_time = (int)lv_slider_get_value(slider);
    int min = 0, second = 0, fs = 0;
    sscanf(arr1, "%d:%d", &min, &second);
    int length_time = 60 * min + second;
    sscanf(buf, "%d", &fs);
    double xiaoshu = fs * 0.01;
    int set_time   = (int)(length_time * xiaoshu);
    printf("time=%d\n", set_time);
    char brr[128] = {0};
    sprintf(brr, "seek %d 2", set_time);
    write(fd, brr, strlen(brr));
}
static void btn_handler(lv_event_t * e)
{
    lv_event_code_t code = lv_event_get_code(e);
    // 获取传递的参数
    char * msg = lv_event_get_user_data(e);
    if(code == LV_EVENT_CLICKED) // 点击按钮
    {
        if(strcmp(msg, "pause") == 0) {
            system("killall -19 mplayer");
        }
        if(strcmp(msg, "play") == 0) {
            system("killall -18 mplayer"); // 播放器继续
        }
        if(strcmp(msg, "forward") == 0) {
            system("echo seek +10 > /pipe");
        }
        if(strcmp(msg, "back") == 0) {
            system("echo seek -10 > /pipe");
        }
        // if(strcmp(msg,"next_music") == 0)
        // {
        //     usleep(1000);
        //     //播放模式
        //     int mod = lv_dropdown_get_selected(play_mode);
        //     switch (mod)
        //     {
        //     case 1:
        //     {
        //         play_one_music();break;
        //     }
        //     case 0:
        //     case 2://列表循环
        //     {
        //         if(++music_index >= music_num)music_index=0;
        //         play_one_music();
        //         break;
        //     }
        //     case 3://随机播放
        //     {
        //         srand((unsigned)time(NULL));
        //         music_index = (music_index+rand())%music_num;
        //         printf("music_index %d\n",music_index);
        //         play_one_music();
        //         break;
        //     }
        //     default:
        //         break;
        //     }
        // }
        // if(strcmp(msg,"prev_music") == 0)
        // {
        //     usleep(1000);
        //     //播放模式
        //     int mod = lv_dropdown_get_selected(play_mode);
        //     switch (mod)
        //     {
        //     case 1://循环播放
        //     { char cmd[1024]={"loop -1\n"};write(fd,cmd,strlen(cmd));
        //     strcpy(cmd,"loop 1\n");write(fd,cmd,strlen(cmd));play_one_music();break;}
        //     case 0://单曲
        //     case 2://列表循环
        //     {
        //         if(--music_index <= 0)music_index=music_num-1;
        //         play_one_music();
        //         break;
        //     }
        //     case 3://随机播放
        //     {
        //         srand((unsigned)time(NULL));
        //         music_index = (music_index+rand())%music_num;
        //         play_one_music();
        //         break;
        //     }
        //     default:
        //         break;
        //     }
        // }
    }
}
static void slider_event_cb(lv_event_t * e)
{
    char * msg = lv_event_get_user_data(e);
    // puts(msg);
    if(strcmp(msg, "volume") == 0) {
        lv_obj_t * slider = lv_event_get_target(e);    // 获取事件对象
        char buf[8];
        int volume = (int)lv_slider_get_value(slider); // 获取值
        lv_snprintf(buf, sizeof(buf), "%d", volume);
        lv_label_set_text(volume_label, buf);          // 更新音量标签值
        lv_obj_align_to(volume_label, slider, LV_ALIGN_OUT_BOTTOM_MID, 0, 10);

        usleep(100); // 修改音量值
        char cmd[1024] = {0};
        sprintf(cmd, "volume %d 1\n", volume);
        write(fd, cmd, strlen(cmd));
    }
}
